home *** CD-ROM | disk | FTP | other *** search
/ Fifty: Elektronik / FIFTY Elektronik (PS_Computer_Vertrieb).iso / ps8 / fty1017 / gepackt.exe / DISK2 / PLOTSRC.EXE / GEOTOOL.INC < prev    next >
Encoding:
Text File  |  1993-11-10  |  15.3 KB  |  690 lines
  1. Procedure Vect_Diff(Var A,B,S :Vektor);
  2. begin
  3.   S.X:=A.X-B.X;
  4.   S.Y:=A.Y-B.Y;
  5. end;
  6.  
  7. Procedure Vect_Sum(Var A,B,S :Vektor);
  8. begin
  9.   S.X:=A.X+B.X;
  10.   S.Y:=A.Y+B.Y;
  11. end;
  12.  
  13. Procedure Vect_Scale(Var V:Vektor;M:Real);
  14. begin
  15.   V.X:=V.X*M;
  16.   V.Y:=V.Y*M;
  17. end;
  18.  
  19. Procedure Vect_Ortho(A:Vektor;Var N :Vektor);
  20. begin
  21.   N.X:=A.Y;
  22.   N.Y:=-A.X;
  23. end;
  24.  
  25. Function Bogenmass(Phi:Real):Real;
  26. begin
  27.   Bogenmass:=Phi*Pi/180.0;
  28. end;
  29.  
  30. Function Winkelmass(Phi:Real):Real;
  31. begin
  32.   Winkelmass:=180.0*Phi/Pi;
  33. end;
  34.  
  35. Function Winkel(X,Y:Real):Real; { gibt Bogenmass }
  36.  
  37. Var Phi,
  38.     Xabs,Yabs :Real;
  39.  
  40.   begin
  41.     Xabs:=Abs(X);
  42.     Yabs:=Abs(Y);
  43.     If (Xabs<FastNull) and (Yabs<FastNull) then Phi:=0
  44.     else If Xabs<FastNull then
  45.       If Y>0 then Phi:=Pi_halbe else Phi:=-Pi_halbe
  46.     else
  47.       begin
  48.         Phi:=ArcTan(Y/X);
  49.         If X<0 then Phi:=Pi+Phi;
  50.       end;
  51.     If Phi<0 then Phi:=Phi+Pi_2;
  52.     Winkel:=Phi;
  53.   end;
  54.  
  55. Procedure Normalize(Var Phi :Integer);
  56. begin
  57.   Phi:=Phi mod 360;
  58.   If Phi <0 Then Inc(Phi,360);
  59. end;
  60.  
  61. Procedure Norm_CircPhi(Var Alpha,Beta :Integer);
  62. begin
  63.   Normalize(Alpha);
  64.   Normalize(Beta);
  65.   If Beta<=Alpha Then Inc(Beta,360);
  66. end;
  67.  
  68. Procedure Normalize_Real(Var Phi :Real);
  69. Var Rest :Real;
  70. begin
  71.   Phi:=Frac(PHi/Pi_2)*Pi_2;
  72.   If Phi <0 Then Phi:=Phi+Pi_2;
  73. end;
  74.  
  75. Procedure Norm_CircPhi_Real(Var Alpha,Beta :Real);
  76. begin
  77.   Normalize_Real(Alpha);
  78.   Normalize_Real(Beta);
  79.   If Beta-Alpha<=FastNull Then Beta:=Beta+Pi_2;
  80. end;
  81.  
  82.  Function DeltaPhi(Phi1,Phi2:Real):Real;
  83.  begin
  84.    Normalize_Real(Phi1);
  85.    Normalize_Real(Phi2);
  86.    Phi1:=Phi2-Phi1;
  87.    Normalize_Real(Phi1);
  88.    If Phi1>Pi then Phi1:=Phi1-Pi_2;
  89.    DeltaPhi:=Phi1;
  90.  end;
  91.  
  92.  
  93. Function InArc(Alpha,Beta,Phi :Real):Boolean;
  94. Const Eps=0.003;
  95. begin
  96.   Normalize_Real(Phi);
  97.   Norm_CircPhi_Real(alpha,beta);
  98.   If (Beta>Pi_2) and (Phi<Alpha) Then Phi:=Phi+Pi_2;
  99.   InArc:=(Phi>=Alpha-Eps) and (Phi<=Beta+Eps);
  100. end;
  101.  
  102. Function CalcPhi(X,Y :Real):Integer;
  103. begin
  104.   CalcPhi:=Round(Winkelmass(Winkel(X,Y)));
  105. end;
  106.  
  107. Procedure Rotiere(Var X,Y:Real;Phi :Real); { Phi :Bogenmass}
  108. Var Si,Co,X1 :Real;
  109. begin
  110.   X1:=X;
  111.   Si:=Sin(Phi);Co:=Cos(Phi);
  112.   X:=X*Co-Y*Si;
  113.   Y:=X1*Si+Y*Co;
  114. end;
  115.  
  116.  
  117. Function Laenge(X,Y :Real):Real;
  118. begin
  119.   Laenge:=Sqrt(Sqr(X)+Sqr(Y));
  120. end;
  121.  
  122. Function Distanz(X1,Y1,X2,Y2 :Real):Real;
  123. begin
  124.   Distanz:=Laenge(X2-X1,Y2-Y1);
  125. end;
  126.  
  127. Function Distanz_VV(Var V1,V2 :Vektor):Real;
  128. begin
  129.   Distanz_VV:=Distanz(V1.X,V1.Y,V2.X,V2.Y);
  130. end;
  131.  
  132. Function Scalar_Prod(A,B :Vektor):Real;
  133. begin
  134.   Scalar_Prod:=(A.X*B.X+A.Y*B.Y);
  135. end;
  136.  
  137.  
  138. Function Loese_QGl(A,B,C :Real;Var X1,X2 :Real):Integer;
  139. Var Diskriminante,D:Real;
  140. begin
  141.   X1:=0;
  142.   X2:=0;
  143.   Loese_Qgl:=0;
  144.   If Abs(A)>FastNull Then
  145.     begin
  146.       C:=C/A;
  147.       B:=B/A;
  148.       Diskriminante:=Sqr(B)-4.0*C;
  149.       If Diskriminante>=0 Then
  150.       begin
  151.         D:=Sqrt(Diskriminante);
  152.         Loese_Qgl:=2;
  153.         If D<FastNull then Loese_QGL:=1;
  154.         X1:=(D-B)/2.0;
  155.         X2:=-(D+B)/2.0;
  156.       end;
  157.      end
  158.       else
  159.        If Abs(B)>Fastnull Then
  160.        begin
  161.          X1:=-C/B;
  162.          X2:=X1;
  163.          Loese_Qgl:=-1; {Linearer  Fall};
  164.        end;
  165.     end;
  166.  
  167. Procedure Tausche(Var X,Y :Real);
  168. Var T :Real;
  169. begin T:=X; X:=Y; Y:=T; end;
  170.  
  171. Procedure Exchange(Var X,Y :Integer);
  172. Var T :Integer;
  173. begin T:=X; X:=Y; Y:=T; end;
  174.  
  175.  
  176. Function Loese_LinGL2(Var A,A1,B :Vektor;Var X :Vektor):Boolean;
  177. Var Pivot:Real;
  178. begin
  179.   X.X:=0;X.Y:=0;
  180.   Loese_LinGl2:=false;
  181.   If Abs(A.X)<Fastnull Then
  182.     begin
  183.       Tausche(A.X,A.Y);
  184.       Tausche(A1.X,A1.Y);
  185.       Tausche(B.X,B.Y);
  186.     end;
  187.   If Abs(A.X)>Fastnull Then
  188.    begin
  189.      Pivot:=A.Y/A.X;
  190.      A1.Y:=A1.Y-A1.X*Pivot;
  191.      B.Y:=B.Y-B.X*Pivot;
  192.      If Abs(A1.Y*A.X)>Fastnull Then
  193.      begin
  194.         Loese_LinGl2:=true;
  195.         X.Y:=B.Y/A1.Y;
  196.         X.X:=(B.X-A1.X*X.Y)/A.X
  197.      end;
  198.    end;
  199. end;
  200.  
  201. Function HNF(Var G:Gerade):Boolean;
  202. Var L:Real;
  203.     OK:Boolean;
  204. begin
  205.   L:=Laenge(G.Richtung.X,G.Richtung.Y);
  206.   OK:=L>FastNull;
  207.   With G.Richtung Do
  208.     If OK Then
  209.      begin
  210.       If (X*G.Ort.Y-Y*G.Ort.X)>0 Then L:=-L;
  211.         begin
  212.           X:=X/L;
  213.           Y:=Y/L;
  214.          end;
  215.       end
  216.     else
  217.       begin X:=0;Y:=0; end;
  218.   HNF:=OK;
  219. end;
  220.  
  221.  
  222. Function Make_Gerade(X1,Y1,X2,Y2:Real;Var G:Gerade):Boolean;
  223. begin
  224.   G.Richtung.X:=X2-X1;
  225.   G.Richtung.Y:=Y2-Y1;
  226.   G.Ort.X:=X1;
  227.   G.Ort.Y:=Y1;
  228.   Make_Gerade:=HNF(G);
  229. end;
  230.  
  231. Function Schnitt_GG(Var G1,G2 :Gerade; Var P :Vektor):Boolean;
  232. Var A,A1,B :Vektor;
  233. begin
  234.   With G1 do
  235.   begin
  236.     A.X:=Richtung.Y;
  237.     A1.X:=-Richtung.X;
  238.     B.X:=Ort.X*Richtung.Y-Ort.Y*Richtung.X;
  239.    end;
  240.   With G2 do
  241.   begin
  242.     A.Y:=Richtung.Y;
  243.     A1.Y:=-Richtung.X;
  244.     B.Y:=Ort.X*Richtung.Y-Ort.Y*Richtung.X;
  245.    end;
  246.    Schnitt_GG:=Loese_LinGL2(A,A1,B,P);
  247. end;
  248.  
  249. Function Abstand(G:Gerade;P:Vektor):Real;
  250. begin
  251.   Abstand:=G.Richtung.Y*(P.X-G.Ort.X)-G.Richtung.X*(P.Y-G.Ort.Y);
  252. end;
  253.  
  254. Function Winkel_halb(G1,G2 : Gerade;P:Vektor;Var G3 :Gerade):Boolean;
  255. Var OK:Boolean;
  256.     SP :Vektor;
  257.     Spitz:Boolean;
  258.     DP1,DP2 :Real;
  259. begin
  260.   OK:=Schnitt_GG(G1,G2,SP);
  261.   If OK Then
  262.   begin
  263.     G3.Ort:=SP;
  264.     DP1:=Abstand(G1,P);
  265.     DP2:=Abstand(G2,P);
  266.     Spitz:=DP1*DP2>0;
  267.     With G3.Richtung Do
  268.     begin
  269.       Vect_Sum(G1.Richtung,G2.Richtung,G3.Richtung);
  270.       If Spitz Then
  271.        begin
  272.          Tausche(X,Y);
  273.          X:=-X;
  274.        end;
  275.     end;
  276.     OK:=HNF(G3);
  277.   end;
  278.   Winkel_halb:=Ok;
  279. end;
  280.  
  281. Function Lot(Var G1: Gerade;P:Vektor;Var PL :Vektor;Var GL :Gerade):Boolean;
  282. Var OK:Boolean;
  283. begin
  284.   GL.Ort:=P;
  285.   Vect_Ortho(G1.Richtung,Gl.Richtung);
  286.   OK:=HNF(GL);
  287.   If OK Then OK:=Schnitt_GG(G1,GL,PL) and ok;
  288.   Lot:=OK;
  289. end;
  290.  
  291. Function Parallele(Var G1:Gerade;Var P1:Vektor; Var GP :Gerade):Boolean;
  292. begin
  293.   GP.Ort:=P1;
  294.   GP.Richtung:=G1.Richtung;
  295.   Parallele:=HNF(GP);
  296. end;
  297.  
  298. Procedure KreisKoord(Rx,Ry,Phi :Real;Var Cx,Cy :Real);
  299. begin
  300.   Cx:=Rx*Cos(Phi);
  301.   Cy:=Ry*Sin(Phi);
  302. end;
  303.  
  304. Function KreisPhi(Var X,Y :Real;Var K:Bogen):Real;
  305. begin
  306.   KreisPhi:=Winkel(X*K.RadiusY,Y*K.RadiusX);
  307. end;
  308.  
  309. Function GetKreisPhi(Var P:Vektor;Var K:Bogen):Real;
  310.  begin
  311.    Norm_KoordSys(P,K.Mitte,K.Theta);
  312.    GetKreisPhi:=KreisPhi(P.X,P.Y,K);
  313.  end;
  314.  
  315.  
  316. Procedure Norm_KoordSys(Var V, V0 :Vektor;Phi:Real);
  317. begin
  318.   Vect_Diff(V,V0,V);
  319.   Rotiere(V.X,V.Y,-Phi);
  320. end;
  321.  
  322. Procedure Regen_KoordSys(Var V, V0 :Vektor;Phi:Real);
  323. begin
  324.   Rotiere(V.X,V.Y,Phi);
  325.   Vect_Sum(V,V0,V);
  326. end;
  327.  
  328. Procedure Get_P_G(Var G1 :Gerade;Var P:Vektor;Sigma :Real);
  329. begin
  330.   P:=G1.Richtung;
  331.   Vect_Scale(P,Sigma);
  332.   Vect_Sum(G1.Ort,P,P);
  333. end;
  334.  
  335.  
  336. Function Tangente(K1 :Bogen;P1 :Vektor;Var PB1,PB2 :Vektor):Integer;
  337. Var Kreis :Bogen;
  338.     KreisPhi0,
  339.     Cx,Cy        :Real;
  340.     InKreis  :Boolean;
  341.     Result,UV:Array[1..2] of Vektor;
  342.     Nr,N,I       :Integer;
  343.     A,B,C,
  344.     A2,B2,Bx,By,K,S :Real;
  345.  
  346.   Procedure GetResult(I :Integer);
  347.   Var Phi :Real;
  348.       XP :Vektor;
  349.   Begin
  350.     A:=B2*Sqr(UV[I].X)+A2*Sqr(UV[I].Y);
  351.     B:=P1.X*UV[I].X*B2+P1.Y*UV[I].Y*A2;
  352.     IF Abs(A) >FastNull Then
  353.       begin
  354.         S:=-B/A;
  355.         Vect_Scale(UV[I],S);
  356.         Vect_Sum(P1,UV[I],XP);
  357.         Phi:=KreisPhi(XP.X,XP.Y,Kreis);
  358.         If InArc(Kreis.alpha,Kreis.Beta,Phi) Then
  359.         begin
  360.           Inc(Nr,1);
  361.           Result[Nr]:=XP;
  362.           Regen_KoordSys(Result[Nr],K1.Mitte,K1.Theta);
  363.         end;
  364.       end;
  365.   end;
  366.  
  367. begin
  368.   FillChar(Result,Sizeof(Result),0);
  369.   Norm_KoordSys(P1,K1.Mitte,K1.Theta);
  370.   { Kordinaten-Transformation in Null-Normal}
  371.   { bezüglich Kreis}
  372.   Kreis:=K1;
  373.   Kreis.Theta:=0;
  374.   Kreis.Mitte:=Nullpunkt;
  375.   KreisPhi0:=KreisPhi(P1.X,P1.Y,Kreis);
  376.   KreisKoord(Kreis.RadiusX,Kreis.RadiusY,KreisPhi0,Cx,Cy);
  377.   InKreis:=(Laenge(Cx,Cy)-Laenge(P1.X,P1.Y))*0.1>FastNull;
  378.   Nr:=0;
  379.   If Not(Inkreis) Then
  380.     begin
  381.       A2:=Sqr(Kreis.RadiusX);B2:=Sqr(Kreis.RadiusY);
  382.       K:=Sqr(P1.X)*B2+Sqr(P1.Y)*A2-A2*B2;
  383.       BX:=2.0*P1.X*B2;
  384.       BY:=2.0*P1.Y*A2;
  385.       A:=Sqr(By)-4.0*A2*K;
  386.       B:=2.0*Bx*By;
  387.       C:=Sqr(Bx)-4.0*B2*K;
  388.       For I:=1 to 2 Do
  389.           begin
  390.             UV[I].X:=1.0;
  391.             UV[I].Y:=1.0;
  392.           end;
  393.       Nr:=Loese_Qgl(A,B,C,UV[1].Y,UV[2].Y);
  394.       If Nr<1 then
  395.         begin
  396.           C:=Sqr(By)-4.0*A2*K;
  397.           A:=Sqr(Bx)-4.0*B2*K;
  398.           Nr:=Loese_Qgl(A,B,C,UV[1].X,UV[2].X);
  399.         end;
  400.       N:=Nr;
  401.       Nr:=0;
  402.       For I:=1 to N do Getresult(I);
  403.     end; {If Inkreis }
  404.   PB1:=Result[1];
  405.   PB2:=Result[2];
  406.   Tangente:=Nr;
  407. end;
  408.  
  409. Function Polare(K1 :Bogen;P1 :Vektor;Var P2,P3 :Vektor; Var G :Gerade):Boolean;
  410. begin
  411.  Polare:=false;
  412.  If Tangente(K1,P1,P2,P3)=2 Then
  413.     begin
  414.       G.Ort:=P2;
  415.       Vect_Diff(P3,P2,G.Richtung);
  416.       Polare:=Hnf(G);
  417.     end;
  418. end;
  419.  
  420.  
  421. Function Schnitt_KG(G1 :Gerade;K1:Bogen;Var P1,P2 :Vektor):Integer;
  422. Var Kreis:Bogen;
  423.     A2,B2,A,B,C :Real;
  424.     S     :Array[1..2] of Real;
  425.     Nr,I,N:Integer;
  426.     Result,Ps: Array[1..2] of Vektor;
  427.  
  428. Procedure GetResult(I :Integer);
  429. Var Phi :Real;
  430.   Begin
  431.     Phi:=KreisPhi(Ps[I].X,Ps[I].Y,Kreis);
  432.     If InArc(Kreis.alpha,Kreis.Beta,Phi) Then
  433.     begin
  434.       Inc(Nr,1);
  435.       Result[Nr]:=Ps[I];
  436.       Regen_KoordSys(Result[Nr],K1.Mitte,K1.Theta);
  437.     end;
  438.   end;
  439.  
  440. Begin
  441.   FillChar(Result,Sizeof(Result),0);
  442.   Norm_KoordSys(G1.Ort,K1.Mitte,K1.Theta);
  443.   Rotiere(G1.Richtung.X,G1.Richtung.Y,-K1.Theta);
  444.   { Kordinaten-Transformation in Null-Normal}
  445.   { bezüglich Kreis}
  446.   Kreis:=K1;
  447.   Kreis.Theta:=0;
  448.   Kreis.Mitte:=Nullpunkt;
  449.   A2:=Sqr(Kreis.RadiusX);B2:=Sqr(Kreis.RadiusY);
  450.   With G1.Ort do
  451.     C:=Sqr(X)*B2+Sqr(Y)*A2-A2*B2;
  452.   With G1 do
  453.     B:=2.0*(Ort.X*Richtung.X*B2+Ort.Y*Richtung.Y*A2);
  454.   With G1.Richtung Do
  455.     A:=B2*Sqr(X)+A2*Sqr(Y);
  456.   Nr:=Loese_QGL(A,B,C,S[1],S[2]);
  457.   For I:=1 to Nr Do
  458.      Get_P_G(G1,Ps[I],S[I]);
  459.   N:=Nr;
  460.   Nr:=0;
  461.   For I:=1 to N do GetResult(I);
  462.   P1:=Result[1];
  463.   P2:=Result[2];
  464.   Schnitt_KG:=Nr;
  465. end;
  466.  
  467.  
  468. Function  Kreis_3P(P1,P2,P3 :Vektor;Var K:Bogen):Integer;
  469. Var Ms1,Ms2 :Gerade;
  470.     V:Vektor;
  471.     X:Vektor;
  472.     Delta:Real;
  473.     Ok:Boolean;
  474. begin
  475.   With K Do
  476.   begin
  477.   Kreis_3P:=0;
  478.   Ok := (Distanz_VV(P1,P2)>Fastnull) and
  479.         (Distanz_VV(P1,P3)>Fastnull) and
  480.         (Distanz_VV(P3,P2)>Fastnull);
  481.    If Ok Then
  482.    begin
  483.      Vect_Sum(P1,P2,Ms1.Ort);
  484.      Vect_Scale(Ms1.Ort,0.5);
  485.      Vect_Sum(P2,P3,Ms2.Ort);
  486.      Vect_Scale(Ms2.Ort,0.5);
  487.      Vect_Diff(P2,P1,V);
  488.      Vect_Ortho(V,Ms1.Richtung);
  489.      Ok:=HNF(Ms1);
  490.      If Ok Then
  491.      begin
  492.        Vect_Diff(P3,P2,V);
  493.        Vect_Ortho(V,Ms2.Richtung);
  494.        Ok:=HNF(Ms1);
  495.        If OK Then
  496.          begin
  497.            Ok:=Schnitt_GG(Ms1,Ms2,Mitte);
  498.            If OK Then
  499.              Begin
  500.                Theta:=0;
  501.                RadiusX:=Distanz_VV(Mitte,P1);
  502.                RadiusY:=RadiusX;
  503.                Vect_Diff(P1,Mitte,X);
  504.                Alpha:=Winkel(X.X,X.Y);
  505.                Vect_Diff(P3,Mitte,X);
  506.                Beta:=Winkel(X.X,X.Y);
  507.                Vect_Diff(P2,Mitte,X);
  508.                Delta:=Winkel(X.X,X.Y);
  509.                Normalize_Real(Alpha);
  510.                Normalize_Real(Beta);
  511.                Normalize_Real(Delta);
  512.                If Not(InArc(Alpha,Beta,Delta)) Then Tausche(Alpha,Beta);
  513.                Kreis_3P:=1;
  514.              End else Kreis_3P:=2; { Gerade P1,P3 }
  515.          end;
  516.      end;
  517.    end;
  518.    end;
  519. end;
  520.  
  521. Function  Kreis_SEC(P1,P2 :Vektor;Var K:Bogen):Boolean;
  522. Var V :Vektor;
  523.     Phi:Real;
  524. begin
  525.   Kreis_Sec:=false;
  526.   V:=P1;
  527.   Norm_KoordSys(V,K.Mitte,K.Theta);
  528.   If Laenge(V.X,V.Y)>FastNull Then
  529.   begin
  530.     Phi:=KreisPhi(V.X,V.Y,K);
  531.     KreisKoord(K.RadiusX,K.RadiusY,Phi,P2.X,P2.Y);
  532.     Regen_KoordSys(P2,K.Mitte,K.Theta);
  533.     Kreis_Sec:=true;
  534.   End;
  535. end;
  536.  
  537. Procedure Koord_to_Vekt(Var K:Koord;Var V:Vektor);
  538. begin
  539.   V.X:=K.X;
  540.   V.Y:=K.Y;
  541. end;
  542.  
  543. Procedure Vekt_to_Koord(Var V:Vektor;Var K:Koord);
  544. begin
  545.   K.X:=RealtoInt(V.X);
  546.   K.Y:=RealtoInt(V.Y);
  547. end;
  548.  
  549. Function Linie_OK(Var O :Bildelement):Boolean;
  550. begin
  551.   Linie_OK:=(O.ElementTyp in [Linie,M_line]) and
  552.             ((O.Aufhaenger.X<>O.Endpunkt.X) or (O.Aufhaenger.Y<>O.Endpunkt.Y));
  553. end;
  554.  
  555. Function Circle_OK(Var O :Bildelement):Boolean;
  556. begin
  557.   With O Do
  558.   Circle_OK:=(ElementTyp in [Kreis,M_arc]) and
  559.              (HalbX>0) and (HalbY>0) and (Segmentalpha<>SegmentBeta);
  560. end;
  561.  
  562. Function  GetObj_Kreis(Var K:Bogen; Var O:Bildelement):Boolean;
  563. begin
  564.   Fillchar(O,SizeOf(O),0);
  565.   With O,K do
  566.   begin
  567.     ElementTyp:=Kreis;
  568.     HalbX:=RealtoInt(RadiusX);
  569.     HalbY:=RealtoInt(RadiusY);
  570.     SegmentAlpha:=RealtoInt(Winkelmass(Alpha));
  571.     Segmentbeta:=RealtoInt(Winkelmass(Beta));
  572.     Orient:=RealtoInt(Winkelmass(Theta));
  573.     Vekt_to_Koord(Mitte,Aufhaenger);
  574.     GetObj_Kreis:=Circle_OK(O);
  575.    end;
  576. end;
  577.  
  578. Function  GetKreis_Obj( Var O:Bildelement;Var K:Bogen):Boolean;
  579. begin
  580.   GetKreis_Obj:=false;
  581.   Fillchar(K,SizeOf(K),0);
  582.   If (O.ElementTyp in [Kreis,M_arc]) then
  583.   With O,K do
  584.   begin
  585.     GetKreis_Obj:=True;
  586.     RadiusX:=HalbX;
  587.     RadiusY:=HalbY;
  588.     Alpha:=Bogenmass(Segmentalpha);
  589.     Beta:=Bogenmass(Segmentbeta);
  590.     Theta:=Bogenmass(Orient);
  591.     Koord_to_Vekt(Aufhaenger,Mitte);
  592.    end;
  593. end;
  594.  
  595.  
  596.  
  597. Function  GetObj_Gerade(Var P1,P2:Vektor; Var O:Bildelement):Boolean;
  598. begin
  599.   Fillchar(O,SizeOf(O),0);
  600.   With O do
  601.   begin
  602.     ElementTyp:=Linie;
  603.     Vekt_to_Koord(P1,Aufhaenger);
  604.     Vekt_to_Koord(P2,Endpunkt);
  605.     GetObj_Gerade:=Linie_OK(O);
  606.    end;
  607. end;
  608.  
  609.  
  610. Function  GetGerade_Obj( Var O:Bildelement;Var G:Gerade):Boolean;
  611. begin
  612.   GetGerade_Obj:=False;
  613.   If (O.ElementTyp in [Linie,M_Line]) then
  614.   With O Do
  615.     GetGerade_Obj:=Make_Gerade(Aufhaenger.X,Aufhaenger.Y,
  616.                                EndPunkt.X,EndPunkt.Y,G);
  617. end;
  618.  
  619.  
  620. Procedure Mirror(Var Px,Py :integer; Spiegel :Spiegelpar);
  621. Var P1,P2 :Real;
  622. begin
  623.   P1:=Px;
  624.   P2:=Py;
  625.   With Spiegel Do
  626.   begin
  627.     Px:=RealtoInt(A11*P1+A12*P2+Ex);
  628.     Py:=RealtoInt(A21*P1+A22*P2+Ey);
  629.   end;
  630. end;
  631.  
  632. Procedure GetSpiegel(Ax,Ay,Bx,By :Integer;Lot,TextMirr:Boolean;
  633.                      Var Spiegel :Spiegelpar);
  634. Var DeltaX,DeltaY,N,
  635.     DXY,DX2,DY2,L  :Real;
  636. begin
  637.   If Lot then L:=1.0
  638.   else L:=2.0;
  639.   DeltaX:=Bx-Ax;
  640.   DeltaY:=By-Ay;
  641.   DXY:=DeltaX*DeltaY;
  642.   DX2:=Sqr(DeltaX);
  643.   DY2:=Sqr(DeltaY);
  644.   N:=DX2+DY2;
  645.   With Spiegel Do
  646.   begin
  647.     If DeltaX<0 then DeltaY:=-DeltaY;
  648.     Phiaxis:=CalcPhi(Abs(DeltaX),DeltaY);
  649.     A11:=1.0-L*DY2/N;
  650.     A12:=L*DXY/N;
  651.     A21:=A12;
  652.     A22:=1.0-L*DX2/N;
  653.     Ex:=L*(DY2*Ax-DXY*Ay)/N;
  654.     Ey:=L*(DX2*Ay-DXY*Ax)/N;
  655.     Mirrtext:=TextMirr;
  656.   end;
  657. end;
  658.  
  659. Function ConvertRect(Var O:Bildelement;
  660.                       Var P1,P2,P3,P4 :Vektor;
  661.                       Var G1,G2,G3,G4 :Gerade):Boolean;
  662. Var Theta,lb       :Real;
  663.     P0  :vektor;
  664. begin
  665.   With O do
  666.   begin
  667.     Lb:=0.5*Rand+Fastnull;
  668.     Koord_to_Vekt(Aufhaenger,P0);
  669.     P1.X:=Lb;          P1.Y:=LB;
  670.     P2.X:=Rlaenge-LB;  P2.Y:=LB;
  671.     P3.X:=P2.X;        P3.y:=Rbreite-LB;
  672.     P4.X:=LB;          P4.y:=P3.y;
  673.     Theta:=Bogenmass(Orient);
  674.     Rotiere(P1.X,P1.Y,Theta);
  675.     Rotiere(P2.X,P2.Y,Theta);
  676.     Rotiere(P3.X,P3.Y,Theta);
  677.     Rotiere(P4.X,P4.Y,Theta);
  678.     Vect_Sum(P0,P1,P1);
  679.     Vect_Sum(P0,P2,P2);
  680.     Vect_Sum(P0,P3,P3);
  681.     Vect_Sum(P0,P4,P4);
  682.     G1.Ort:=P1;G2.Ort:=P2;G3.Ort:=P3;G4.Ort:=P4;
  683.     Vect_Diff(P2,P1,G1.Richtung);
  684.     Vect_Ortho(G1.Richtung,G2.Richtung);
  685.     G3.Richtung:=G1.Richtung;G4.Richtung:=G2.Richtung;
  686.     ConvertRect:=Hnf(G1) and HNF(G2) and HNF(G3) and HNF(G4);
  687.   end;
  688. end;
  689.  
  690.